#encoding:utf-8
import os
import nltk

def L1Set():#计算每一个1频繁项目对应的用例集合
    l1=open('e:\\ObjectMap.txt')#ObjectMap.txt文件存储了每一个类对应的索引号
    map={}
    for l in l1:
        temp=l.strip().split(':')
        map[temp[0]]=temp[1]
    l1.close()

    files=os.listdir('E:\\TracesFrequency\\')
    dic={}#获取每一个用例包含的对象，格式为：用例索引：[对象索引]，例如'54771':['2','23',....]
    for file in files:
        f=open('E:\\TracesFrequency\\'+file)
        items=[]
        for line in f:
            temp=line.strip().split(',')
            if temp[1] in map.keys():
                items.append(map[temp[1]])
        dic[file[:-4]]=items
        f.close()
    
    f=open('e:\\L1.txt')#L1.txt文件定义了1频繁项目集合有哪些类组成
    L=[]#计算频繁项目1集
    for line in f:
        temp=line.strip().split(',')
        i=0
        while i<len(temp):
            if i%2==0:
                L.append(temp[i])
            i+=1
    f.close()

    j=0
    result={}#用于记录每一个1频繁项目对应的用例集合，格式：1频繁项目：[用例索引]
    while j<len(L):
        trans=[]
        for k in dic.keys():
            if L[j] in dic[k]:
                trans.append(k)
        result[L[j]]=trans
        j+=1

    return result

def L1sem():#计算L1集合的语意关键词集合
    files=os.listdir('e:\\Queries\\')#读取用例的文字描述
    UsecaseSem={}
    for file in files:
        output=set()#用于记录每一个用例对应那些语意关键字
        f=open('e:\\Queries\\'+file)
        for line in f:
            text=nltk.word_tokenize(line)
            temp=nltk.pos_tag(text)
        output=output|set(temp)
        UsecaseSem[file[15:-4]]=output
        f.close()
    L1S={}#用于存储L1集合中每一个元素所对应的语意关键字
    result=L1Set()
    for k in result.keys():
        usecase=result[k]
        sem=UsecaseSem[usecase[0]]
        i=1
        while i<len(sem):
            sem=sem&UsecaseSem[usecase[i]]
            i+=1
        L1S[k]=sem
    return L1S

def annotation():#规则注释. 还存在问题还需要进一步调整
    semantic=L1sem()
    f=open('e:\\Rules.txt')
    ruset={}
    for l in f:
        temp=l.strip().split('@')
        ru=temp[0].split(',')
        i=0
        index=0
        ls=[]
        while i<len(ru):
            if i%2==0:
                ls.append(ru[i])
            i+=1
        ruset[index]=ls#记录一条规则中包含多少个类，或者说多少个1频繁项目集
        index+=1
    f.close()
    result={}
    j=0
    for k in ruset.keys():
        tp=ruset[k]
        means=semantic[tp[0]]
        m=1
        while m<len(tp):
            means=means|semantic[tp[m]]
            m+=1
        result[j]=means
        j+=1
    return result#记录每一条与规则的语意